{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据加载及处理\n",
    "\n",
    "[![](https://gitee.com/mindspore/docs/raw/master/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/master/tutorials/source_zh_cn/dataset.ipynb)&emsp;[![](https://gitee.com/mindspore/docs/raw/master/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/master/quick_start/mindspore_dataset.ipynb)&emsp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MindSpore提供了部分常用数据集和标准格式数据集的加载接口，用户可以直接使用`mindspore.dataset`中对应的数据集加载类进行数据加载。数据集类为用户提供了常用的数据处理接口，使得用户能够快速进行数据处理操作。\n",
    "\n",
    "## 加载数据集\n",
    "\n",
    "下面的样例通过`Cifar10Dataset`接口加载CIFAR-10数据集，使用顺序采样器获取前5个样本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.dataset as ds\n",
    "\n",
    "DATA_DIR = \"./datasets/cifar-10-batches-bin/train\"\n",
    "sampler = ds.SequentialSampler(num_samples=5)\n",
    "dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 迭代数据集\n",
    "\n",
    "用户可以用`create_dict_iterator`创建数据迭代器，迭代访问数据，下面展示了对应图片的形状和标签。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape: (32, 32, 3) , Label: 6\n",
      "Image shape: (32, 32, 3) , Label: 9\n",
      "Image shape: (32, 32, 3) , Label: 9\n",
      "Image shape: (32, 32, 3) , Label: 4\n",
      "Image shape: (32, 32, 3) , Label: 1\n"
     ]
    }
   ],
   "source": [
    "for data in dataset.create_dict_iterator():\n",
    "    print(\"Image shape: {}\".format(data['image'].shape), \", Label: {}\".format(data['label']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 自定义数据集\n",
    "\n",
    "对于目前MindSpore不支持直接加载的数据集，可以构造自定义数据集类，然后通过`GeneratorDataset`接口实现自定义方式的数据加载。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.random.seed(58)\n",
    "\n",
    "class DatasetGenerator:\n",
    "    def __init__(self):\n",
    "        self.data = np.random.sample((5, 2))\n",
    "        self.label = np.random.sample((5, 1))\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.data[index], self.label[index]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中用户需要自定义的类函数如下：\n",
    "\n",
    "- **\\_\\_init\\_\\_**\n",
    "\n",
    "    实例化数据集对象时，`__init__`函数被调用，用户可以在此进行数据初始化等操作。\n",
    "\n",
    "    ```python\n",
    "    def __init__(self):\n",
    "        self.data = np.random.sample((5, 2))\n",
    "        self.label = np.random.sample((5, 1))\n",
    "    ```\n",
    "\n",
    "- **\\_\\_getitem\\_\\_**\n",
    "\n",
    "    定义数据集类的`__getitem__`函数，使其支持随机访问，能够根据给定的索引值`index`，获取数据集中的数据并返回。\n",
    "\n",
    "    ```python\n",
    "    def __getitem__(self, index):\n",
    "        return self.data[index], self.label[index]\n",
    "    ```\n",
    "\n",
    "- **\\_\\_len\\_\\_**\n",
    "\n",
    "    定义数据集类的`__len__`函数，返回数据集的样本数量。\n",
    "\n",
    "    ```python\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    ```\n",
    "    \n",
    "定义数据集类之后，就可以通过`GeneratorDataset`接口按照用户定义的方式加载并访问数据集样本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.36510558 0.45120592] [0.78888122]\n",
      "[0.49606035 0.07562207] [0.38068183]\n",
      "[0.57176158 0.28963401] [0.16271622]\n",
      "[0.30880446 0.37487617] [0.54738768]\n",
      "[0.81585667 0.96883469] [0.77994068]\n"
     ]
    }
   ],
   "source": [
    "dataset_generator = DatasetGenerator()\n",
    "dataset = ds.GeneratorDataset(dataset_generator, [\"data\", \"label\"], shuffle=False)\n",
    "\n",
    "for data in dataset.create_dict_iterator():\n",
    "    print('{}'.format(data[\"data\"]), '{}'.format(data[\"label\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 数据处理及增强\n",
    "\n",
    "### 数据处理\n",
    "\n",
    "MindSpore提供的数据集接口具备常用的数据处理方法，用户只需调用相应的函数接口即可快速进行数据处理。\n",
    "\n",
    "下面的样例先将数据集随机打乱顺序，然后将样本两两组成一个批次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data: [[0.36510558 0.45120592]\n",
      " [0.57176158 0.28963401]]\n",
      "label: [[0.78888122]\n",
      " [0.16271622]]\n",
      "data: [[0.30880446 0.37487617]\n",
      " [0.49606035 0.07562207]]\n",
      "label: [[0.54738768]\n",
      " [0.38068183]]\n",
      "data: [[0.81585667 0.96883469]]\n",
      "label: [[0.77994068]]\n"
     ]
    }
   ],
   "source": [
    "ds.config.set_seed(58)\n",
    "\n",
    "# 随机打乱数据顺序\n",
    "dataset = dataset.shuffle(buffer_size=10)\n",
    "# 对数据集进行分批\n",
    "dataset = dataset.batch(batch_size=2)\n",
    "\n",
    "for data in dataset.create_dict_iterator():\n",
    "    print(\"data: {}\".format(data[\"data\"]))\n",
    "    print(\"label: {}\".format(data[\"label\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中，\n",
    "\n",
    "`buffer_size`：数据集中进行shuffle操作的缓存区的大小。\n",
    "\n",
    "`batch_size`：每组包含的数据个数，现设置每组包含2个数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 数据增强\n",
    "\n",
    "数据量过小或是样本场景单一等问题会影响模型的训练效果，用户可以通过数据增强操作扩充样本多样性，从而提升模型的泛化能力。\n",
    "\n",
    "下面的样例使用`mindspore.dataset.vision.c_transforms`模块中的算子对MNIST数据集进行数据增强。\n",
    "\n",
    "导入`c_transforms`模块，加载MNIST数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from mindspore.dataset.vision import Inter\n",
    "import mindspore.dataset.vision.c_transforms as c_vision\n",
    "\n",
    "DATA_DIR = './datasets/MNIST_Data/train'\n",
    "\n",
    "mnist_dataset = ds.MnistDataset(DATA_DIR, num_samples=6, shuffle=False)\n",
    "\n",
    "# 查看数据原图\n",
    "mnist_it = mnist_dataset.create_dict_iterator()\n",
    "data = next(mnist_it)\n",
    "plt.imshow(data['image'].asnumpy().squeeze(), cmap=plt.cm.gray)\n",
    "plt.title(data['label'].asnumpy(), fontsize=20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "定义数据增强算子，对数据集进行`Resize`和`RandomCrop`操作，然后通过`map`映射将其插入数据处理管道。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "resize_op = c_vision.Resize(size=(200,200), interpolation=Inter.LINEAR)\n",
    "crop_op = c_vision.RandomCrop(150)\n",
    "transforms_list = [resize_op, crop_op]\n",
    "mnist_dataset = mnist_dataset.map(operations=transforms_list, input_columns=[\"image\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "查看数据增强效果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mnist_dataset = mnist_dataset.create_dict_iterator()\n",
    "data = next(mnist_dataset)\n",
    "plt.imshow(data['image'].asnumpy().squeeze(), cmap=plt.cm.gray)\n",
    "plt.title(data['label'].asnumpy(), fontsize=20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "想要了解更多可以参考编程指南中[数据增强](https://www.mindspore.cn/doc/programming_guide/zh-CN/master/augmentation.html)章节。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MindSpore-1.1.1",
   "language": "python",
   "name": "mindspore-1.1.1"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
